package com.tbynet.jwp.service.support;

import com.jfinal.kit.StrKit;
import com.jfinal.log.Log;
import com.tbynet.jwp.framework.core.JwpCache;
import com.tbynet.jwp.repository.dto.result.TermResult;

import java.math.BigInteger;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Supplier;

/**
 * 分类项缓存管理器
 * 基于 JwpCache 的增强实现，专门处理分类项相关缓存
 *
 * @author 佰亿互联
 * @version 3.0
 * @since 2025-11-04
 */
public class TermCacheManager extends JwpCache {

    /** 日志记录器 */
    private final Log log = Log.getLog(this.getClass());

    /** 缓存名称常量 */
    public static final String TERM_CACHE = "termCache";
    public static final String TAXONOMY_CACHE = "taxonomyCache";
    public static final String HIERARCHY_CACHE = "hierarchyCache";
    public static final String STATISTICS_CACHE = "statisticsCache";

    /** 缓存依赖关系映射 */
    private final Map<String, Set<String>> cacheDependencies = new ConcurrentHashMap<>();

    /** 缓存监控器 */
    private final TermCacheMonitor cacheMonitor;

    public TermCacheManager() {
        this.cacheMonitor = new TermCacheMonitor(this);
        initializeCacheDependencies();
    }

    /**
     * 初始化缓存依赖关系
     */
    private void initializeCacheDependencies() {
        // 分类项缓存依赖的缓存
        Set<String> termDependencies = new HashSet<>();
        termDependencies.add(HIERARCHY_CACHE);
        termDependencies.add(STATISTICS_CACHE);
        termDependencies.add(TAXONOMY_CACHE);
        cacheDependencies.put(TERM_CACHE, termDependencies);

        // 层级缓存依赖的缓存
        Set<String> hierarchyDependencies = new HashSet<>();
        hierarchyDependencies.add(STATISTICS_CACHE);
        cacheDependencies.put(HIERARCHY_CACHE, hierarchyDependencies);

        // 分类法缓存依赖的缓存
        Set<String> taxonomyDependencies = new HashSet<>();
        taxonomyDependencies.add(STATISTICS_CACHE);
        cacheDependencies.put(TAXONOMY_CACHE, taxonomyDependencies);
    }

    // ========== 缓存键构建方法 ==========

    /**
     * 构建安全的分类项缓存键
     * 使用标准化格式，避免键冲突
     *
     * @param termId 分类项ID
     * @param taxonomy 分类法类型
     * @return 安全的缓存键
     */
    public String buildTermCacheKey(BigInteger termId, String taxonomy) {
        // 参数验证和标准化
        String termIdStr = termId != null ? termId.toString() : "null";
        String taxonomyStr = taxonomy != null ? taxonomy.trim() : "all";

        // 替换可能引起冲突的特殊字符
        taxonomyStr = taxonomyStr.replace(":", "_");

        return buildCacheKey("term", termIdStr, taxonomyStr);
    }

    /**
     * 构建安全的层级结构缓存键
     *
     * @param taxonomy 分类法类型
     * @param parentId 父级ID
     * @return 安全的缓存键
     */
    public String buildHierarchyCacheKey(String taxonomy, BigInteger parentId) {
        String taxonomyStr = taxonomy != null ? taxonomy.trim().replace(":", "_") : "all";
        String parentIdStr = parentId != null ? parentId.toString() : "root";

        return buildCacheKey("hierarchy", taxonomyStr, parentIdStr);
    }

    /**
     * 构建统计缓存键
     */
    public String buildStatisticsCacheKey(String taxonomy) {
        return buildCacheKey("statistics", taxonomy != null ? taxonomy : "all");
    }

    /**
     * 构建分类法缓存键
     */
    public String buildTaxonomyCacheKey(String taxonomy) {
        return buildCacheKey("taxonomy", taxonomy != null ? taxonomy : "all");
    }

    // ========== 基础缓存操作方法 ==========

    /**
     * 获取缓存对象
     */
    public <T> T getCache(String cacheName, Object key) {
        return getCache(cacheName, key, null);
    }

    /**
     * 设置缓存对象
     */
    public void putCache(String cacheName, Object key, Object value) {
        setCache(cacheName, key, value);
    }

    // ========== 业务缓存操作方法 ==========

    /**
     * 获取分类项缓存数据
     */
    public <T> T getTermWithCache(BigInteger termId, String taxonomy, Supplier<T> loader) {
        String cacheKey = buildTermCacheKey(termId, taxonomy);
        T result = getMultiLevelCache(TERM_CACHE, cacheKey, loader);
        if (result != null) {
            cacheMonitor.recordHit("term");
        } else {
            cacheMonitor.recordMiss("term");
        }
        return result;
    }

    /**
     * 获取层级缓存数据
     */
    public <T> T getHierarchyWithCache(String taxonomy, BigInteger parentId, Supplier<T> loader) {
        String cacheKey = buildHierarchyCacheKey(taxonomy, parentId);
        T result = getMultiLevelCache(HIERARCHY_CACHE, cacheKey, loader);
        if (result != null) {
            cacheMonitor.recordHit("hierarchy");
        } else {
            cacheMonitor.recordMiss("hierarchy");
        }
        return result;
    }

    /**
     * 获取分类法缓存数据
     */
    public <T> T getTaxonomyCache(String key, Supplier<T> loader) {
        T result = getMultiLevelCache(TAXONOMY_CACHE, key, loader);
        if (result != null) {
            cacheMonitor.recordHit("taxonomy");
        } else {
            cacheMonitor.recordMiss("taxonomy");
        }
        return result;
    }

    /**
     * 获取统计缓存数据
     */
    public <T> T getStatisticsWithCache(String taxonomy, Supplier<T> loader) {
        String cacheKey = buildStatisticsCacheKey(taxonomy);
        T result = getMultiLevelCache(STATISTICS_CACHE, cacheKey, loader);
        if (result != null) {
            cacheMonitor.recordHit("statistics");
        } else {
            cacheMonitor.recordMiss("statistics");
        }
        return result;
    }

    // ========== 缓存清理方法 ==========

    /**
     * 移除分类项缓存
     */
    public void removeTermCache(BigInteger termId, String taxonomy) {
        if (termId == null || taxonomy == null) {
            return;
        }

        String cacheKey = buildTermCacheKey(termId, taxonomy);
        try {
            // 移除分类项本身缓存
            removeCache(TERM_CACHE, cacheKey);
            cacheMonitor.recordEviction("term");
            log.debug("移除分类项缓存: %s", cacheKey);

            // 清理相关缓存
            cleanRelatedCaches(taxonomy, termId);

        } catch (Exception e) {
            log.error("移除分类项缓存失败, termId: %s, taxonomy: %s", termId, taxonomy, e);
        }
    }

    /**
     * 移除层级结构缓存
     */
    public void removeHierarchyCache(String taxonomy, BigInteger parentId) {
        try {
            String cacheKey = buildHierarchyCacheKey(taxonomy, parentId);
            removeCache(HIERARCHY_CACHE, cacheKey);
            cacheMonitor.recordEviction("hierarchy");
            log.debug("移除层级结构缓存: %s", cacheKey);

            // 清理相关的统计缓存
            if (parentId == null) {
                cleanRelatedStatisticsCache(taxonomy);
            }

        } catch (Exception e) {
            log.warn("移除层级结构缓存失败, taxonomy: %s, parentId: %s", taxonomy, parentId, e);
        }
    }

    /**
     * 移除分类法缓存数据
     */
    public void removeTaxonomyCache(String key) {
        removeCache(TAXONOMY_CACHE, key);
        cacheMonitor.recordEviction("taxonomy");

        // 清理相关的统计缓存
        if (key.startsWith("taxonomy:")) {
            String taxonomy = key.substring("taxonomy:".length());
            if (!"list".equals(taxonomy)) {
                cleanRelatedStatisticsCache(taxonomy);
            }
        }
    }

    /**
     * 清理相关缓存
     */
    private void cleanRelatedCaches(String taxonomy, BigInteger termId) {
        try {
            // 清理层级缓存
            removeHierarchyCache(taxonomy, termId);
            removeHierarchyCache(taxonomy, null);

            // 清理统计缓存
            cleanRelatedStatisticsCache(taxonomy);

            // 清理分类法缓存
            cleanRelatedTaxonomyCache(taxonomy);

        } catch (Exception e) {
            log.warn("清理相关缓存异常, taxonomy: %s, termId: %s", taxonomy, termId, e);
        }
    }

    /**
     * 清理相关统计缓存
     */
    private void cleanRelatedStatisticsCache(String taxonomy) {
        try {
            String statisticsKey = buildStatisticsCacheKey(taxonomy);
            removeCache(STATISTICS_CACHE, statisticsKey);
            cacheMonitor.recordEviction("statistics");

            // 清理全局统计缓存
            removeCache(STATISTICS_CACHE, buildStatisticsCacheKey(null));

            log.debug("清理统计缓存完成, taxonomy: %s", taxonomy);
        } catch (Exception e) {
            log.warn("清理统计缓存异常, taxonomy: %s", taxonomy, e);
        }
    }

    /**
     * 清理相关分类法缓存
     */
    private void cleanRelatedTaxonomyCache(String taxonomy) {
        try {
            if (taxonomy != null) {
                String taxonomyKey = buildTaxonomyCacheKey(taxonomy);
                removeCache(TAXONOMY_CACHE, taxonomyKey);
                cacheMonitor.recordEviction("taxonomy");

                // 清理分类法列表缓存
                removeCache(TAXONOMY_CACHE, "taxonomy:list");

                // 清理默认分类项缓存
                removeCache(TAXONOMY_CACHE, "default:" + taxonomy);
            }
            log.debug("清理分类法缓存完成, taxonomy: %s", taxonomy);
        } catch (Exception e) {
            log.warn("清理分类法缓存异常, taxonomy: %s", taxonomy, e);
        }
    }

    // ========== 批量操作方法 ==========

    /**
     * 批量移除分类项缓存
     */
    public void batchRemoveTermCache(List<BigInteger> termIds, String taxonomy) {
        if (termIds == null || termIds.isEmpty()) {
            return;
        }

        try {
            Set<BigInteger> processedTerms = new HashSet<>();

            // 批量移除单个分类项缓存
            for (BigInteger termId : termIds) {
                if (processedTerms.add(termId)) {
                    removeTermCache(termId, taxonomy);
                }
            }

            // 批量清理相关缓存
            removeHierarchyCache(taxonomy, null);
            cleanRelatedStatisticsCache(taxonomy);
            cleanRelatedTaxonomyCache(taxonomy);

            log.info("批量移除分类项缓存完成, 数量: %s, taxonomy: %s", termIds.size(), taxonomy);

        } catch (Exception e) {
            log.error("批量移除分类项缓存失败, taxonomy: %s", taxonomy, e);
        }
    }

    /**
     * 批量全面清理缓存
     */
    public void batchComprehensiveClean(List<BigInteger> termIds, String taxonomy, List<TermResult> termInfos) {
        if (termIds == null || termIds.isEmpty()) {
            return;
        }

        // 批量移除缓存
        batchRemoveTermCache(termIds, taxonomy);

        // 如果有分类项信息，清理额外的相关缓存
        if (termInfos != null && !termInfos.isEmpty()) {
            for (TermResult termInfo : termInfos) {
                if (termInfo != null && termInfo.getParentId() != null &&
                        !termInfo.getParentId().equals(BigInteger.ZERO)) {
                    removeHierarchyCache(taxonomy, termInfo.getParentId());
                }
            }
        }

        log.info("批量全面清理缓存完成: termCount=%s, taxonomy=%s", termIds.size(), taxonomy);
    }

    // ========== 原子操作方法 ==========

    /**
     * 原子操作：清理缓存并重新加载
     */
    public <T> T refreshTermCache(BigInteger termId, String taxonomy, Supplier<T> loader) {
        String cacheKey = buildTermCacheKey(termId, taxonomy);

        try {
            log.debug("开始原子刷新缓存: termId=%s, taxonomy=%s", termId, taxonomy);

            // 1. 先清理相关缓存
            removeTermCache(termId, taxonomy);

            // 2. 然后立即加载新数据
            T result = loader.get();

            // 3. 重新放入缓存
            if (result != null) {
                putCache(TERM_CACHE, cacheKey, result);
                log.debug("原子刷新缓存成功: termId=%s, taxonomy=%s", termId, taxonomy);
            } else {
                log.warn("原子刷新缓存加载到空数据: termId=%s, taxonomy=%s", termId, taxonomy);
            }

            return result;

        } catch (Exception e) {
            log.error("原子刷新缓存失败: termId=%s, taxonomy=%s", termId, taxonomy, e);
            return loader.get(); // 降级处理
        }
    }

    /**
     * 增强版缓存清理 - 处理所有相关缓存
     */
    public void comprehensiveCleanTermCache(BigInteger termId, String taxonomy, TermResult termInfo) {
        if (termId == null || taxonomy == null) {
            return;
        }

        try {
            log.debug("开始全面清理分类项缓存: termId=%s, taxonomy=%s", termId, taxonomy);

            // 1. 清理分类项本身缓存
            removeTermCache(termId, taxonomy);

            // 2. 如果有分类项信息，清理额外的层级缓存
            if (termInfo != null) {
                if (termInfo.getParentId() != null && !termInfo.getParentId().equals(BigInteger.ZERO)) {
                    removeHierarchyCache(taxonomy, termInfo.getParentId());
                }
            }

            log.debug("全面清理分类项缓存完成: termId=%s, taxonomy=%s", termId, taxonomy);

        } catch (Exception e) {
            log.error("全面清理分类项缓存失败: termId=%s, taxonomy=%s", termId, taxonomy, e);
        }
    }

    // ========== 高级功能方法 ==========

    /**
     * 完全清理分类法所有缓存
     */
    public void completelyCleanTaxonomyCache(String taxonomy) {
        if (taxonomy == null) {
            return;
        }

        try {
            log.info("开始完全清理分类法缓存: taxonomy=%s", taxonomy);

            // 清理分类法缓存
            removeTaxonomyCache("taxonomy:" + taxonomy);
            removeTaxonomyCache("default:" + taxonomy);

            // 清理层级缓存
            removeHierarchyCache(taxonomy, null);

            // 清理统计缓存
            cleanRelatedStatisticsCache(taxonomy);

            log.info("完全清理分类法缓存完成, taxonomy: %s", taxonomy);
        } catch (Exception e) {
            log.error("完全清理分类法缓存失败, taxonomy: %s", taxonomy, e);
        }
    }

    /**
     * 清理所有缓存
     */
    public void cleanAllCache() {
        try {
            log.info("开始清理所有分类项相关缓存");

            // 清理所有缓存类型
            clearCache(TERM_CACHE);
            clearCache(TAXONOMY_CACHE);
            clearCache(HIERARCHY_CACHE);
            clearCache(STATISTICS_CACHE);

            log.info("清理所有分类项相关缓存完成");
        } catch (Exception e) {
            log.error("清理所有缓存失败", e);
        }
    }

    // ========== 监控和诊断方法 ==========

    /**
     * 获取缓存统计信息
     */
    public Map<String, Object> getCacheStats() {
        Map<String, Object> stats = new HashMap<>();

        try {
            stats.put("lastCleanTime", new Date());
            stats.put("status", "active");
            stats.put("cacheTypes", Arrays.asList(TERM_CACHE, TAXONOMY_CACHE, HIERARCHY_CACHE, STATISTICS_CACHE));

            // 添加监控统计
            stats.put("monitorStats", cacheMonitor.getDetailedCacheStatistics());

        } catch (Exception e) {
            log.warn("获取缓存统计信息失败", e);
            stats.put("error", e.getMessage());
        }

        return stats;
    }

    /**
     * 检查缓存健康状况
     */
    public Map<String, Object> checkCacheHealth() {
        Map<String, Object> health = new HashMap<>();
        health.put("timestamp", new Date());

        try {
            // 检查各缓存类型的基本状态
            health.put("termCache", checkCacheTypeHealth(TERM_CACHE));
            health.put("taxonomyCache", checkCacheTypeHealth(TAXONOMY_CACHE));
            health.put("hierarchyCache", checkCacheTypeHealth(HIERARCHY_CACHE));
            health.put("statisticsCache", checkCacheTypeHealth(STATISTICS_CACHE));

            health.put("overallStatus", "HEALTHY");

        } catch (Exception e) {
            log.error("检查缓存健康状况失败", e);
            health.put("overallStatus", "ERROR");
            health.put("error", e.getMessage());
        }

        return health;
    }

    /**
     * 检查特定缓存类型的健康状况
     */
    private Map<String, Object> checkCacheTypeHealth(String cacheType) {
        Map<String, Object> health = new HashMap<>();
        health.put("cacheType", cacheType);
        health.put("status", "ACTIVE");
        health.put("lastAccess", new Date());
        return health;
    }

    /**
     * 获取缓存监控器
     */
    public TermCacheMonitor getCacheMonitor() {
        return cacheMonitor;
    }

    // ========== 缓存工具方法 ==========

    /**
     * 预加载热门分类项缓存
     */
    public void preloadPopularTerms(String taxonomy, int limit) {
        try {
            log.debug("预加载热门分类项缓存: taxonomy=%s, limit=%s", taxonomy, limit);

            // 这里可以调用相关服务预加载数据
            // 实际实现取决于具体业务需求

        } catch (Exception e) {
            log.warn("预加载热门分类项缓存失败: taxonomy=%s", taxonomy, e);
        }
    }

    /**
     * 预加载层级结构缓存
     */
    public void preloadHierarchy(String taxonomy) {
        try {
            log.debug("预加载层级结构缓存: taxonomy=%s", taxonomy);

            // 预加载根层级
            getHierarchyWithCache(taxonomy, null, () -> {
                // 这里返回空列表，实际加载由调用方处理
                return Collections.emptyList();
            });

        } catch (Exception e) {
            log.warn("预加载层级结构缓存失败: taxonomy=%s", taxonomy, e);
        }
    }

    /**
     * 验证缓存参数
     */
    private void validateCacheParams(String cacheName, Object key) {
        if (cacheName == null || cacheName.trim().isEmpty()) {
            throw new IllegalArgumentException("缓存名称不能为空");
        }
        if (key == null) {
            throw new IllegalArgumentException("缓存键不能为空");
        }
    }

    /**
     * 安全的缓存获取（带降级保护）
     * 当缓存操作失败时，降级到直接查询，保证系统可用性
     *
     * @param termId 分类项ID
     * @param taxonomy 分类法类型
     * @param loader 数据加载器
     * @param <T> 数据类型
     * @return 数据对象
     */
    public <T> T getTermWithCacheSafely(BigInteger termId, String taxonomy, Supplier<T> loader) {
        if (termId == null || StrKit.isBlank(taxonomy)) {
            log.warn("缓存获取参数错误，直接调用加载器: termId=%s, taxonomy=%s", termId, taxonomy);
            return loader.get();
        }

        try {
            String cacheKey = buildTermCacheKey(termId, taxonomy);
            T result = getMultiLevelCache(TERM_CACHE, cacheKey, loader);

            if (result != null) {
                cacheMonitor.recordHit("term");
            } else {
                cacheMonitor.recordMiss("term");
            }

            return result;

        } catch (Exception e) {
            // 缓存操作失败时降级到直接查询
            log.warn("缓存获取失败，降级到直接查询: termId=%s, taxonomy=%s, error=%s",
                    termId, taxonomy, e.getMessage());
            cacheMonitor.recordMiss("term");
            return loader.get();
        }
    }

    /**
     * 安全的缓存设置（带异常处理）
     *
     * @param termId 分类项ID
     * @param taxonomy 分类法类型
     * @param value 缓存值
     */
    public void setTermCacheSafely(BigInteger termId, String taxonomy, Object value) {
        if (termId == null || StrKit.isBlank(taxonomy) || value == null) {
            return;
        }

        try {
            String cacheKey = buildTermCacheKey(termId, taxonomy);
            putCache(TERM_CACHE, cacheKey, value);
            log.debug("缓存设置成功: termId=%s, taxonomy=%s", termId, taxonomy);
        } catch (Exception e) {
            log.warn("缓存设置失败: termId=%s, taxonomy=%s, error=%s",
                    termId, taxonomy, e.getMessage());
            // 不抛出异常，避免影响主业务流程
        }
    }

    /**
     * 优化的批量缓存清理
     * 分批处理，添加延迟，避免对缓存服务造成过大压力
     *
     * @param termIds 分类项ID列表
     * @param taxonomy 分类法类型
     */
    public void batchRemoveTermCacheOptimized(List<BigInteger> termIds, String taxonomy) {
        if (termIds == null || termIds.isEmpty() || StrKit.isBlank(taxonomy)) {
            log.warn("批量缓存清理参数错误");
            return;
        }

        try {
            log.info("开始优化批量缓存清理: 数量=%s, taxonomy=%s", termIds.size(), taxonomy);

            // 分批处理参数
            int batchSize = 50; // 每批处理数量
            int delayMillis = 5; // 批次间延迟(毫秒)

            // 分批处理
            for (int i = 0; i < termIds.size(); i += batchSize) {
                int endIndex = Math.min(i + batchSize, termIds.size());
                List<BigInteger> batch = termIds.subList(i, endIndex);

                // 处理当前批次
                for (BigInteger termId : batch) {
                    removeTermCache(termId, taxonomy);
                }

                // 添加延迟，避免对缓存服务造成过大压力
                if (endIndex < termIds.size()) {
                    try {
                        Thread.sleep(delayMillis);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        log.warn("批量缓存清理被中断");
                        break;
                    }
                }

                log.debug("批量缓存清理进度: %s/%s", endIndex, termIds.size());
            }

            log.info("优化批量缓存清理完成: 总数=%s, taxonomy=%s", termIds.size(), taxonomy);

        } catch (Exception e) {
            log.error("优化批量缓存清理失败: taxonomy=%s, error=%s", taxonomy, e.getMessage(), e);
        }
    }

    /**
     * 智能缓存预热
     * 在批量操作后预热常用缓存，提升后续查询性能
     *
     * @param taxonomy 分类法类型
     * @param preloadLimit 预加载数量限制
     */
    public void intelligentPreload(String taxonomy, int preloadLimit) {
        if (StrKit.isBlank(taxonomy)) {
            return;
        }

        try {
            log.debug("开始智能缓存预热: taxonomy=%s, limit=%s", taxonomy, preloadLimit);

            // 预热根层级缓存
            getHierarchyWithCache(taxonomy, null, () -> {
                log.debug("预热根层级缓存完成: taxonomy=%s", taxonomy);
                return Collections.emptyList();
            });

            // 预热热门分类项（如果有相关服务）
            preloadPopularTerms(taxonomy, Math.min(preloadLimit, 20));

            log.debug("智能缓存预热完成: taxonomy=%s", taxonomy);

        } catch (Exception e) {
            log.warn("智能缓存预热失败: taxonomy=%s", taxonomy, e);
        }
    }

    /**
     * 智能缓存清理策略
     * 避免过度清理，只清理真正相关的缓存
     *
     * @param taxonomy 分类法类型
     * @param termId 分类项ID
     * @param termInfo 分类项信息
     */
    public void smartCleanRelatedCaches(String taxonomy, BigInteger termId, TermResult termInfo) {
        if (termId == null || StrKit.isBlank(taxonomy)) {
            return;
        }

        try {
            log.debug("开始智能缓存清理: termId=%s, taxonomy=%s", termId, taxonomy);

            // 1. 总是清理分类项本身缓存
            removeTermCache(termId, taxonomy);

            // 2. 根据分类项信息决定清理范围
            if (termInfo != null) {
                // 清理直接父级的层级缓存
                if (termInfo.getParentId() != null && !termInfo.getParentId().equals(BigInteger.ZERO)) {
                    removeHierarchyCache(taxonomy, termInfo.getParentId());
                    log.debug("清理父级层级缓存: parentId=%s", termInfo.getParentId());
                }

                // 如果当前分类项有子项，清理以其为父级的层级缓存
                if (hasChildren(termInfo)) {
                    removeHierarchyCache(taxonomy, termId);
                    log.debug("清理子项层级缓存: termId=%s", termId);
                }
            } else {
                // 没有分类项信息时，保守清理
                removeHierarchyCache(taxonomy, null);
                log.debug("保守清理: 清理所有层级缓存");
            }

            // 3. 选择性清理统计缓存（只在计数变化时）
            if (termInfo != null && termInfo.getCount() != null && termInfo.getCount() > 0) {
                cleanRelatedStatisticsCache(taxonomy);
                log.debug("清理统计缓存: 分类项有使用计数");
            }

            log.debug("智能缓存清理完成: termId=%s, taxonomy=%s", termId, taxonomy);

        } catch (Exception e) {
            log.error("智能缓存清理失败: termId=%s, taxonomy=%s", termId, taxonomy, e);
        }
    }

    /**
     * 判断分类项是否有子项（基于缓存或查询）
     *
     * @param termInfo 分类项信息
     * @return 是否有子项
     */
    private boolean hasChildren(TermResult termInfo) {
        // TODO 这里可以根据实际情况实现
        // 例如检查 childrenCount 字段或查询数据库
        // 暂时返回 false 避免过度清理
        return false;
    }

    /**
     * 优化的全面缓存清理
     * 替代原来的 comprehensiveCleanTermCache，避免过度清理
     *
     * @param termId 分类项ID
     * @param taxonomy 分类法类型
     * @param termInfo 分类项信息
     */
    public void optimizedComprehensiveClean(BigInteger termId, String taxonomy, TermResult termInfo) {
        if (termId == null || StrKit.isBlank(taxonomy)) {
            return;
        }

        try {
            log.debug("开始优化全面缓存清理: termId=%s, taxonomy=%s", termId, taxonomy);

            // 使用智能清理策略
            smartCleanRelatedCaches(taxonomy, termId, termInfo);

            // 额外清理：默认分类项缓存（如果被删除的是默认分类项）
            cleanDefaultTermCacheIfNeeded(termId, taxonomy);

            log.debug("优化全面缓存清理完成: termId=%s, taxonomy=%s", termId, taxonomy);

        } catch (Exception e) {
            log.error("优化全面缓存清理失败: termId=%s, taxonomy=%s", termId, taxonomy, e);
        }
    }

    /**
     * 清理默认分类项缓存（如果需要）
     *
     * @param termId 分类项ID
     * @param taxonomy 分类法类型
     */
    private void cleanDefaultTermCacheIfNeeded(BigInteger termId, String taxonomy) {
        try {
            // 检查被删除的是否是默认分类项
            String defaultTermCacheKey = "default:" + taxonomy;
            BigInteger defaultTermId = getCache(TAXONOMY_CACHE, defaultTermCacheKey, null);

            if (termId.equals(defaultTermId)) {
                removeTaxonomyCache(defaultTermCacheKey);
                log.debug("清理默认分类项缓存: termId=%s, taxonomy=%s", termId, taxonomy);
            }
        } catch (Exception e) {
            log.warn("检查默认分类项缓存失败", e);
        }
    }

    /**
     * 执行综合缓存操作
     * 包含监控、错误处理和性能统计
     */
    public <T> T executeCacheOperation(String operationName, Supplier<T> operation) {
        long startTime = System.currentTimeMillis();
        String operationId = generateOperationId();

        log.debug("开始缓存操作: id=%s, name=%s", operationId, operationName);

        try {
            T result = operation.get();
            long duration = System.currentTimeMillis() - startTime;

            // 记录操作耗时
            cacheMonitor.recordOperationDuration(operationName, duration);

            log.debug("缓存操作完成: id=%s, name=%s, 耗时=%sms",
                    operationId, operationName, duration);

            return result;

        } catch (Exception e) {
            cacheMonitor.recordError(operationName);
            log.error("缓存操作失败: id=%s, name=%s", operationId, operationName, e);
            throw e;
        }
    }

    /**
     * 生成操作ID
     */
    private String generateOperationId() {
        return "cache_op_" + System.currentTimeMillis() + "_" +
                Thread.currentThread().getId() + "_" +
                (int)(Math.random() * 1000);
    }

    /**
     * 获取缓存系统状态报告
     */
    public Map<String, Object> getSystemStatusReport() {
        Map<String, Object> report = new HashMap<>();
        report.put("timestamp", new Date());
        report.put("cacheManager", "TermCacheManager");
        report.put("version", "3.0");

        // 健康状态
        report.put("health", checkCacheHealth());

        // 统计信息
        report.put("statistics", cacheMonitor.getDetailedCacheStatistics());

        // 性能指标
        report.put("performance", getPerformanceMetrics());

        // 建议和警告
        report.put("recommendations", generateSystemRecommendations());

        return report;
    }

    /**
     * 获取性能指标
     */
    private Map<String, Object> getPerformanceMetrics() {
        Map<String, Object> metrics = new HashMap<>();

        try {
            Map<String, Object> stats = cacheMonitor.getDetailedCacheStatistics();

            // 提取关键指标
            metrics.put("totalOperations", stats.get("totalOperations"));
            metrics.put("uptimeMinutes", stats.get("uptimeMinutes"));
            metrics.put("cacheTypeStats", stats.get("cacheTypeStats"));
            metrics.put("operationStats", stats.get("operationStats"));

        } catch (Exception e) {
            log.warn("获取性能指标失败", e);
            metrics.put("error", e.getMessage());
        }

        return metrics;
    }

    /**
     * 生成系统建议
     */
    private List<String> generateSystemRecommendations() {
        List<String> recommendations = new ArrayList<>();

        try {
            Map<String, Object> health = checkCacheHealth();
            if ("DEGRADED".equals(health.get("overallStatus"))) {
                @SuppressWarnings("unchecked")
                List<String> issues = (List<String>) health.get("issues");
                if (issues != null) {
                    issues.forEach(issue -> {
                        if (issue.contains("错误率过高")) {
                            recommendations.add("建议检查缓存服务器连接和网络状况");
                        }
                        if (issue.contains("命中率过低")) {
                            recommendations.add("建议优化缓存键设计和数据访问模式");
                        }
                    });
                }
            }

            // 默认建议
            if (recommendations.isEmpty()) {
                recommendations.add("系统运行正常，建议定期监控缓存性能");
                recommendations.add("考虑在低峰期执行缓存预热");
            }

        } catch (Exception e) {
            recommendations.add("无法生成建议: " + e.getMessage());
        }

        return recommendations;
    }

    /**
     * 批量操作执行器
     */
    public void executeBatchOperation(String operationName, Runnable operation) {
        executeCacheOperation(operationName, () -> {
            operation.run();
            return null;
        });
    }
}